package com.gongj.stream.demo1;


import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/*
 *流的中间操作
 */
public class demo2 {
    List<Integer> integers = Arrays.asList(
            1,2,3,4,5,6,7,8,9,10,2,5,7,9,17
    );


    @Test
    public void test1() {
        /**
         * 1.筛选与切片
         *  filter：过滤流中的某些元素
         *  limit(n)：获取n个元素
         *  skip(n)：跳过n元素，若流中元素不足n个，则返回一个空流，配合limit(n)可实现分页
         *  distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素
         */
        // 创建流
        Stream<Integer> stream = integers.stream();
        // 中间操作
        Stream<Integer> employeeStream = stream
                .filter((t) -> t > 5)
                .distinct()
                .skip(2)
                .limit(3);
        employeeStream.forEach(System.out::println);
    }

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99),
            new Employee("李四",38,5555.55),
            new Employee("王五",50,6666.66),
            new Employee("赵六",15,3333.33),
            new Employee("田七",18,7777.77)
    );

    @Test
    public void test2() {
        /**
         * 1.映 射
         *  map(Function f)：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
         */
        // 将每个元素转换为大写
//        List<String> list = Arrays.asList("a,a=","b,b=","cc=","d,d=");
//        List<String> collect = list.stream()
//                .map(str -> str.toUpperCase()).collect(Collectors.toList());
//            // str -> str.toUpperCase() 可以简写为 String::toUpperCase
//        System.out.println(collect);
//        System.out.println("=============");

        List<String> list = Arrays.asList("a,a=","b,b=","cc=","d,d=");
        List<String[]> collect = list.stream()
                .map(str -> str.split(",")).collect(Collectors.toList());
        // str -> str.toUpperCase() 可以简写为 String::toUpperCase
        System.out.println(collect);
        System.out.println("=============");

        //提取员工名称
        employees.stream()
                //.map(employee -> employee.getName())
                //类::实例方法名
                .map(Employee::getName)
                .collect(Collectors.toList());
        System.out.println("=============");

    }

    @Test
    public void test3() {
        /**
         * mapToInt((ToIntFunction f)
         * 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream
         */
        List<String> list = Arrays.asList("a,a","b,b","cc","d,d");
        IntStream intStream = list.stream()
                .mapToInt(str -> {
                    return str.length();
                });

        intStream.forEach(System.out::println);
    }

    @Test
    public void test4() {
        /**
         * flatMap(Function f)
         * 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
         */
        // 将每个元素根据,进行分割
        List<String> list = Arrays.asList("a,a=","b,b=","cc=","d,d=");
        Stream<String> stringStream = list.stream()
                .flatMap(str -> {
                    String[] split = str.split(",");
                    Stream<String> stream = Arrays.stream(split);
                    return stream;
                });
        List<String> collect = stringStream.collect(Collectors.toList());
        System.out.println(collect);
    }

        // 排序
    @Test
    public void test5() {
        /**
         * sorted()
         * 产生一个新流，其中按自然顺序排序
         */
        List<String> list = Arrays.asList("bb","cc","ee","aa");
        list.stream().sorted().forEach(System.out::println);

    }

    @Test
    public void test6() {
        /**
         * sorted(Comparator com) 产生一个新流，其中按比较器顺序排序
         */
        //如果年龄一致，就按照姓名排序，如果不一致，就按照年龄排序
        employees.stream().sorted((e1,e2)->{
            if(e1.getAge().equals(e2.getAge())){
                return e1.getName().compareTo(e2.getName());
            }else{
                return e1.getAge().compareTo(e2.getAge());
            }
        }).forEach(System.out::println);
    }


}
